import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 涛
 * Date: 2023-09-23
 * Time: 17:03
 */
public class MyArrayList implements IList{
    public int[] elem;
    public int usedSize;//顺序表长度，默认为0

    public static final int DEFAULT_SIZE = 10;

    public MyArrayList() {
        this.elem = new int[DEFAULT_SIZE];
    }
    public MyArrayList(int capacity) {
        this.elem = new int[capacity];
    }
    //显示顺序表
    public void display() {
        for (int i = 0; i < usedSize; i++) {
            System.out.println(this.elem[i] + " ");
        }
        System.out.println();
    }

    @Override
    public void add(int data) {
        //判断是否满了
        checkCapacity();

        //添加数组
        this.elem[usedSize] = data;
        this.usedSize++;
    }
    public boolean isFull() {
        return usedSize == elem.length;
    }

    @Override
    public void add(int pos, int data) {
        //判断下标是否合法
        try {
            checkPosOnAdd(pos);
        } catch (Illegal e) {
            e.printStackTrace();
        }
        //判断是否满了
        checkCapacity();
        //开始插入元素

        //如果等于pos == usedSize，直接插入
        if(pos == usedSize) {
            elem[pos] = data;
        }
        //要插入的下标已存在元素

        //usedSize及前面下标的元素往后依次移动，usedSize赋值给i，每移动一次，i--
        int i = usedSize - 1;
        for (; i >= pos; i--) {
            elem[i + 1] = elem[i];
        }
        elem[pos] = data;
        usedSize++;

    }
    private void checkPosOnAdd(int pos) {
        if(pos < 0 || pos > usedSize) {
            System.out.println("下标不合法");
            throw new Illegal("插入下标元素异常" + pos) ;

        }
    }
    private void checkCapacity() {
        if(isFull()) {
            //满了，扩容
            elem = Arrays.copyOf(elem, elem.length * 2);
        }
    }

    @Override
    public boolean contains(int toFind) {
        //遍历顺序表，查找有没有这个元素，如果有，返回true
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    @Override
    public int indexOf(int toFind) {

        //遍历顺序表找到这个数的下标
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == toFind) {
                return i;
            }
        }
        //没有找到，返回-1，因为没有-1下标的顺序表
        return -1;
    }

    @Override
    public int get(int pos) {
        //先判断要找的这个下标是否越界，合法
        try {
            checkPosOnGet(pos);
        } catch (Illegal e) {
            e.printStackTrace();

        }
        //合法
        return elem[pos];

    }
    private void checkPosOnGet(int pos) {
        if(pos < 0 || pos > usedSize) {
            System.out.println("下标不合法");
            throw new Illegal("下标没有这个元素异常" + pos) ;

        }
    }

    @Override
    public void set(int pos, int value) {
        //判断顺序表是否满了，满了-》扩容
        checkCapacity();
        //判断pos位置是否合法
        try {
            checkPosOnSet(pos);
        } catch (Illegal e) {
            e.printStackTrace();
        }
        //合法了，将vallue这个元素设置在pos下标，会覆盖掉原有的元素
        elem[pos] = value;
    }

    private void checkPosOnSet(int pos) {
        if(pos < 0 || pos >= usedSize) {
            System.out.println("下标越界了");
            throw new Illegal("要设置的下标不合法" + pos);
        }
    }

    @Override
    public void remove(int toRemove) {
        //判断有没有这个关键字
        try {
            if(checkToRemoveOnSet(toRemove) == -1) {
                //没有，直接返回
                System.out.println("没有这个数字");
                throw new Illegal("没有您要删除的元素");
            }
        } catch (Illegal e) {
            e.printStackTrace();
        }
        /**
         * 有这个关键字，删除，后面往前面覆盖，最后一个的都要置为空
         *
         */
        int firstKey = checkToRemoveOnSet(toRemove);
        for (int i = firstKey; i < usedSize; i++) {
            elem[i] = elem[i + 1];
        }
        elem[usedSize] = 0;
        usedSize--;
    }
    //找要删第一个关键字的下标
    private int checkToRemoveOnSet(int toRemove) {

        for (int i = 0; i < usedSize; i++) {
            //判断有没有要找的这第一个关键字
            if(elem[i] == toRemove) {
                //如果有，就直接返回这个下标数
                return i;
            }
        }
        //没有，返回-1
        return -1;
    }

    @Override
    public int size() {
        return usedSize;
    }

    @Override
    public void clear() {
        if(usedSize == 0) {
            return;
        }
        int symbol = usedSize;
        for (int i = 0; i < symbol; i++) {
            //置为0
            elem[i] = 0;
            //顺序表usedSize--
            usedSize--;
        }
    }
}
